﻿/*
 * FCKeditor - The text editor for Internet - http://www.fckeditor.net
 * Copyright (C) 2003-2008 Frederico Caldeira Knabben
 *
 * == BEGIN LICENSE ==
 *
 * Licensed under the terms of any of the following licenses at your
 * choice:
 *
 *  - GNU General Public License Version 2 or later (the "GPL")
 *    http://www.gnu.org/licenses/gpl.html
 *
 *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
 *    http://www.gnu.org/licenses/lgpl.html
 *
 *  - Mozilla Public License Version 1.1 or later (the "MPL")
 *    http://www.mozilla.org/MPL/MPL-1.1.html
 *
 * == END LICENSE ==
 *
 * Creation and initialization of the "FCK" object. This is the main object
 * that represents an editor instance.
 */

// FCK represents the active editor instance.
var FCK =
{
    Name: FCKURLParams['InstanceName'],
    Status: FCK_STATUS_NOTLOADED,
    EditMode: FCK_EDITMODE_WYSIWYG,
    Toolbar: null,
    HasFocus: false,
    DataProcessor: new FCKDataProcessor(),

    GetInstanceObject: (function () {
        var w = window;
        return function (name) {
            return w[name];
        }
    })(),

    AttachToOnSelectionChange: function (functionPointer) {
        this.Events.AttachEvent('OnSelectionChange', functionPointer);
    },

    GetLinkedFieldValue: function () {
        return this.LinkedField.value;
    },

    GetParentForm: function () {
        return this.LinkedField.form;
    },

    // # START : IsDirty implementation

    StartupValue: '',

    IsDirty: function () {
        if (this.EditMode == FCK_EDITMODE_SOURCE)
            return (this.StartupValue != this.EditingArea.Textarea.value);
        else {
            // It can happen switching between design and source mode in Gecko
            if (!this.EditorDocument)
                return false;

            return (this.StartupValue != this.EditorDocument.body.innerHTML);
        }
    },

    ResetIsDirty: function () {
        if (this.EditMode == FCK_EDITMODE_SOURCE)
            this.StartupValue = this.EditingArea.Textarea.value;
        else if (this.EditorDocument.body)
            this.StartupValue = this.EditorDocument.body.innerHTML;
    },

    // # END : IsDirty implementation

    StartEditor: function () {
        this.TempBaseTag = FCKConfig.BaseHref.length > 0 ? '<base href="' + FCKConfig.BaseHref + '" _fcktemp="true"></base>' : '';

        // Setup the keystroke handler.
        var oKeystrokeHandler = FCK.KeystrokeHandler = new FCKKeystrokeHandler();
        oKeystrokeHandler.OnKeystroke = _FCK_KeystrokeHandler_OnKeystroke;

        // Set the config keystrokes.
        oKeystrokeHandler.SetKeystrokes(FCKConfig.Keystrokes);

        // In IE7, if the editor tries to access the clipboard by code, a dialog is
        // shown to the user asking if the application is allowed to access or not.
        // Due to the IE implementation of it, the KeystrokeHandler will not work
        //well in this case, so we must leave the pasting keys to have their default behavior.
        if (FCKBrowserInfo.IsIE7) {
            if ((CTRL + 86 /*V*/) in oKeystrokeHandler.Keystrokes)
                oKeystrokeHandler.SetKeystrokes([CTRL + 86, true]);

            if ((SHIFT + 45 /*INS*/) in oKeystrokeHandler.Keystrokes)
                oKeystrokeHandler.SetKeystrokes([SHIFT + 45, true]);
        }

        // Retain default behavior for Ctrl-Backspace. (Bug #362)
        oKeystrokeHandler.SetKeystrokes([CTRL + 8, true]);

        this.EditingArea = new FCKEditingArea(document.getElementById('xEditingArea'));
        this.EditingArea.FFSpellChecker = FCKConfig.FirefoxSpellChecker;

        // Set the editor's startup contents.
        this.SetData(this.GetLinkedFieldValue(), true);

        // Tab key handling for source mode.
        FCKTools.AddEventListener(document, "keydown", this._TabKeyHandler);

        // Add selection change listeners. They must be attached only once.
        this.AttachToOnSelectionChange(_FCK_PaddingNodeListener);
        if (FCKBrowserInfo.IsGecko)
            this.AttachToOnSelectionChange(this._ExecCheckEmptyBlock);

    },

    Focus: function () {
        FCK.EditingArea.Focus();
    },

    SetStatus: function (newStatus) {
        this.Status = newStatus;

        if (newStatus == FCK_STATUS_ACTIVE) {
            FCKFocusManager.AddWindow(window, true);

            if (FCKBrowserInfo.IsIE)
                FCKFocusManager.AddWindow(window.frameElement, true);

            // Force the focus in the editor.
            if (FCKConfig.StartupFocus)
                FCK.Focus();
        }

        this.Events.FireEvent('OnStatusChange', newStatus);

    },

    // Fixes the body by moving all inline and text nodes to appropriate block
    // elements.
    FixBody: function () {
        var sBlockTag = FCKConfig.EnterMode;

        // In 'br' mode, no fix must be done.
        if (sBlockTag != 'p' && sBlockTag != 'div')
            return;

        var oDocument = this.EditorDocument;

        if (!oDocument)
            return;

        var oBody = oDocument.body;

        if (!oBody)
            return;

        FCKDomTools.TrimNode(oBody);

        var oNode = oBody.firstChild;
        var oNewBlock;

        while (oNode) {
            var bMoveNode = false;

            switch (oNode.nodeType) {
                // Element Node.   
                case 1:
                    var nodeName = oNode.nodeName.toLowerCase();
                    if (!FCKListsLib.BlockElements[nodeName] &&
							nodeName != 'li' &&
							!oNode.getAttribute('_fckfakelement') &&
							oNode.getAttribute('_moz_dirty') == null)
                        bMoveNode = true;
                    break;

                // Text Node.   
                case 3:
                    // Ignore space only or empty text.
                    if (oNewBlock || oNode.nodeValue.Trim().length > 0)
                        bMoveNode = true;
                    break;

                // Comment Node   
                case 8:
                    if (oNewBlock)
                        bMoveNode = true;
                    break;
            }

            if (bMoveNode) {
                var oParent = oNode.parentNode;

                if (!oNewBlock)
                    oNewBlock = oParent.insertBefore(oDocument.createElement(sBlockTag), oNode);

                oNewBlock.appendChild(oParent.removeChild(oNode));

                oNode = oNewBlock.nextSibling;
            }
            else {
                if (oNewBlock) {
                    FCKDomTools.TrimNode(oNewBlock);
                    oNewBlock = null;
                }
                oNode = oNode.nextSibling;
            }
        }

        if (oNewBlock)
            FCKDomTools.TrimNode(oNewBlock);
    },

    GetData: function (format) {
        // We assume that if the user is in source editing, the editor value must
        // represent the exact contents of the source, as the user wanted it to be.
        if (FCK.EditMode == FCK_EDITMODE_SOURCE)
            return FCK.EditingArea.Textarea.value;

        this.FixBody();

        var oDoc = FCK.EditorDocument;
        if (!oDoc)
            return null;

        var isFullPage = FCKConfig.FullPage;

        // Call the Data Processor to generate the output data.
        var data = FCK.DataProcessor.ConvertToDataFormat(
			isFullPage ? oDoc.documentElement : oDoc.body,
			!isFullPage,
			FCKConfig.IgnoreEmptyParagraphValue,
			format);

        // Restore protected attributes.
        data = FCK.ProtectEventsRestore(data);

        if (FCKBrowserInfo.IsIE)
            data = data.replace(FCKRegexLib.ToReplace, '$1');

        if (isFullPage) {
            if (FCK.DocTypeDeclaration && FCK.DocTypeDeclaration.length > 0)
                data = FCK.DocTypeDeclaration + '\n' + data;

            if (FCK.XmlDeclaration && FCK.XmlDeclaration.length > 0)
                data = FCK.XmlDeclaration + '\n' + data;
        }

        return FCKConfig.ProtectedSource.Revert(data);
    },

    UpdateLinkedField: function () {
        var value = FCK.GetXHTML(FCKConfig.FormatOutput);

        if (FCKConfig.HtmlEncodeOutput)
            value = FCKTools.HTMLEncode(value);

        FCK.LinkedField.value = value;
        FCK.Events.FireEvent('OnAfterLinkedFieldUpdate');
    },

    RegisteredDoubleClickHandlers: new Object(),

    OnDoubleClick: function (element) {
        var oCalls = FCK.RegisteredDoubleClickHandlers[element.tagName.toUpperCase()];

        if (oCalls) {
            for (var i = 0; i < oCalls.length; i++)
                oCalls[i](element);
        }

        // Generic handler for any element
        oCalls = FCK.RegisteredDoubleClickHandlers['*'];

        if (oCalls) {
            for (var i = 0; i < oCalls.length; i++)
                oCalls[i](element);
        }

    },

    // Register objects that can handle double click operations.
    RegisterDoubleClickHandler: function (handlerFunction, tag) {
        var nodeName = tag || '*';
        nodeName = nodeName.toUpperCase();

        var aTargets;

        if (!(aTargets = FCK.RegisteredDoubleClickHandlers[nodeName]))
            FCK.RegisteredDoubleClickHandlers[nodeName] = [handlerFunction];
        else {
            // Check that the event handler isn't already registered with the same listener
            // It doesn't detect function pointers belonging to an object (at least in Gecko)
            if (aTargets.IndexOf(handlerFunction) == -1)
                aTargets.push(handlerFunction);
        }

    },

    OnAfterSetHTML: function () {
        FCKDocumentProcessor.Process(FCK.EditorDocument);
        FCKUndo.SaveUndoStep();

        FCK.Events.FireEvent('OnSelectionChange');
        FCK.Events.FireEvent('OnAfterSetHTML');
    },

    // Saves URLs on links and images on special attributes, so they don't change when
    // moving around.
    ProtectUrls: function (html) {
        // <A> href
        html = html.replace(FCKRegexLib.ProtectUrlsA, '$& _fcksavedurl=$1');

        // <IMG> src
        html = html.replace(FCKRegexLib.ProtectUrlsImg, '$& _fcksavedurl=$1');

        // <AREA> href
        html = html.replace(FCKRegexLib.ProtectUrlsArea, '$& _fcksavedurl=$1');

        return html;
    },

    // Saves event attributes (like onclick) so they don't get executed while
    // editing.
    ProtectEvents: function (html) {
        return html.replace(FCKRegexLib.TagsWithEvent, _FCK_ProtectEvents_ReplaceTags);
    },

    ProtectEventsRestore: function (html) {
        return html.replace(FCKRegexLib.ProtectedEvents, _FCK_ProtectEvents_RestoreEvents);
    },

    ProtectTags: function (html) {
        var sTags = FCKConfig.ProtectedTags;

        // IE doesn't support <abbr> and it breaks it. Let's protect it.
        if (FCKBrowserInfo.IsIE)
            sTags += sTags.length > 0 ? '|ABBR|XML|EMBED|OBJECT' : 'ABBR|XML|EMBED|OBJECT';

        var oRegex;
        if (sTags.length > 0) {
            oRegex = new RegExp('<(' + sTags + ')(?!\w|:)', 'gi');
            html = html.replace(oRegex, '<FCK:$1');

            oRegex = new RegExp('<\/(' + sTags + ')>', 'gi');
            html = html.replace(oRegex, '<\/FCK:$1>');
        }

        // Protect some empty elements. We must do it separately because the
        // original tag may not contain the closing slash, like <hr>:
        //		- <meta> tags get executed, so if you have a redirect meta, the
        //		  content will move to the target page.
        //		- <hr> may destroy the document structure if not well
        //		  positioned. The trick is protect it here and restore them in
        //		  the FCKDocumentProcessor.
        sTags = 'META';
        if (FCKBrowserInfo.IsIE)
            sTags += '|HR';

        oRegex = new RegExp('<((' + sTags + ')(?=\\s|>|/)[\\s\\S]*?)/?>', 'gi');
        html = html.replace(oRegex, '<FCK:$1 />');

        return html;
    },

    SetData: function (data, resetIsDirty) {
        this.EditingArea.Mode = FCK.EditMode;

        // If there was an onSelectionChange listener in IE we must remove it to avoid crashes #1498
        if (FCKBrowserInfo.IsIE && FCK.EditorDocument) {
            FCK.EditorDocument.detachEvent("onselectionchange", Doc_OnSelectionChange);
        }

        FCKTempBin.Reset();

        if (FCK.EditMode == FCK_EDITMODE_WYSIWYG) {
            // Save the resetIsDirty for later use (async)
            this._ForceResetIsDirty = (resetIsDirty === true);

            // Protect parts of the code that must remain untouched (and invisible)
            // during editing.
            data = FCKConfig.ProtectedSource.Protect(data);

            // Call the Data Processor to transform the data.
            data = FCK.DataProcessor.ConvertToHtml(data);

            // Fix for invalid self-closing tags (see #152).
            data = data.replace(FCKRegexLib.InvalidSelfCloseTags, '$1></$2>');

            // Protect event attributes (they could get fired in the editing area).
            data = FCK.ProtectEvents(data);

            // Protect some things from the browser itself.
            data = FCK.ProtectUrls(data);
            data = FCK.ProtectTags(data);

            // Insert the base tag (FCKConfig.BaseHref), if not exists in the source.
            // The base must be the first tag in the HEAD, to get relative
            // links on styles, for example.
            if (FCK.TempBaseTag.length > 0 && !FCKRegexLib.HasBaseTag.test(data))
                data = data.replace(FCKRegexLib.HeadOpener, '$&' + FCK.TempBaseTag);

            // Build the HTML for the additional things we need on <head>.
            var sHeadExtra = '';

            if (!FCKConfig.FullPage)
                sHeadExtra += _FCK_GetEditorAreaStyleTags();

            if (FCKBrowserInfo.IsIE)
                sHeadExtra += FCK._GetBehaviorsStyle();
            else if (FCKConfig.ShowBorders)
                sHeadExtra += FCKTools.GetStyleHtml(FCK_ShowTableBordersCSS, true);

            sHeadExtra += FCKTools.GetStyleHtml(FCK_InternalCSS, true);

            // Attention: do not change it before testing it well (sample07)!
            // This is tricky... if the head ends with <meta ... content type>,
            // Firefox will break. But, it works if we place our extra stuff as
            // the last elements in the HEAD.
            data = data.replace(FCKRegexLib.HeadCloser, sHeadExtra + '$&');

            // Load the HTML in the editing area.
            this.EditingArea.OnLoad = _FCK_EditingArea_OnLoad;
            this.EditingArea.Start(data);
        }
        else {
            // Remove the references to the following elements, as the editing area
            // IFRAME will be removed.
            FCK.EditorWindow = null;
            FCK.EditorDocument = null;
            FCKDomTools.PaddingNode = null;

            this.EditingArea.OnLoad = null;
            this.EditingArea.Start(data);

            // Enables the context menu in the textarea.
            this.EditingArea.Textarea._FCKShowContextMenu = true;

            // Removes the enter key handler.
            FCK.EnterKeyHandler = null;

            if (resetIsDirty)
                this.ResetIsDirty();

            // Listen for keystroke events.
            FCK.KeystrokeHandler.AttachToElement(this.EditingArea.Textarea);

            this.EditingArea.Textarea.focus();

            FCK.Events.FireEvent('OnAfterSetHTML');
        }

        if (FCKBrowserInfo.IsGecko)
            window.onresize();
    },

    // This collection is used by the browser specific implementations to tell
    // which named commands must be handled separately.
    RedirectNamedCommands: new Object(),

    ExecuteNamedCommand: function (commandName, commandParameter, noRedirect, noSaveUndo) {
        if (!noSaveUndo)
            FCKUndo.SaveUndoStep();

        if (!noRedirect && FCK.RedirectNamedCommands[commandName] != null)
            FCK.ExecuteRedirectedNamedCommand(commandName, commandParameter);
        else {
            FCK.Focus();
            FCK.EditorDocument.execCommand(commandName, false, commandParameter);
            FCK.Events.FireEvent('OnSelectionChange');
        }

        if (!noSaveUndo)
            FCKUndo.SaveUndoStep();
    },

    GetNamedCommandState: function (commandName) {
        try {

            // Bug #50 : Safari never returns positive state for the Paste command, override that.
            if (FCKBrowserInfo.IsSafari && FCK.EditorWindow && commandName.IEquals('Paste'))
                return FCK_TRISTATE_OFF;

            if (!FCK.EditorDocument.queryCommandEnabled(commandName))
                return FCK_TRISTATE_DISABLED;
            else {
                return FCK.EditorDocument.queryCommandState(commandName) ? FCK_TRISTATE_ON : FCK_TRISTATE_OFF;
            }
        }
        catch (e) {
            return FCK_TRISTATE_OFF;
        }
    },

    GetNamedCommandValue: function (commandName) {
        var sValue = '';
        var eState = FCK.GetNamedCommandState(commandName);

        if (eState == FCK_TRISTATE_DISABLED)
            return null;

        try {
            sValue = this.EditorDocument.queryCommandValue(commandName);
        }
        catch (e) { }

        return sValue ? sValue : '';
    },

    Paste: function (_callListenersOnly) {
        // First call 'OnPaste' listeners.
        if (FCK.Status != FCK_STATUS_COMPLETE || !FCK.Events.FireEvent('OnPaste'))
            return false;

        // Then call the default implementation.
        return _callListenersOnly || FCK._ExecPaste();
    },

    PasteFromWord: function () {
        FCKDialog.OpenDialog('FCKDialog_Paste', FCKLang.PasteFromWord, 'dialog/fck_paste.html', 400, 330, 'Word');
    },

    Preview: function () {
        var sHTML;

        if (FCKConfig.FullPage) {
            if (FCK.TempBaseTag.length > 0)
                sHTML = FCK.TempBaseTag + FCK.GetXHTML();
            else
                sHTML = FCK.GetXHTML();
        }
        else {
            sHTML =
				FCKConfig.DocType +
				'<html dir="' + FCKConfig.ContentLangDirection + '">' +
				'<head>' +
				FCK.TempBaseTag +
				'<title>' + FCKLang.Preview + '</title>' +
				_FCK_GetEditorAreaStyleTags() +
				'</head><body' + FCKConfig.GetBodyAttributes() + '>' +
				FCK.GetXHTML() +
				'</body></html>';
        }

        var iWidth = FCKConfig.ScreenWidth * 0.8;
        var iHeight = FCKConfig.ScreenHeight * 0.7;
        var iLeft = (FCKConfig.ScreenWidth - iWidth) / 2;

        var sOpenUrl = '';
        if (FCK_IS_CUSTOM_DOMAIN && FCKBrowserInfo.IsIE) {
            window._FCKHtmlToLoad = sHTML;
            sOpenUrl = 'javascript:void( (function(){' +
				'document.open() ;' +
				'document.domain="' + document.domain + '" ;' +
				'document.write( window.opener._FCKHtmlToLoad );' +
				'document.close() ;' +
				'window.opener._FCKHtmlToLoad = null ;' +
				'})() )';
        }

        var oWindow = window.open(sOpenUrl, null, 'toolbar=yes,location=no,status=yes,menubar=yes,scrollbars=yes,resizable=yes,width=' + iWidth + ',height=' + iHeight + ',left=' + iLeft);

        if (!FCK_IS_CUSTOM_DOMAIN || !FCKBrowserInfo.IsIE) {
            oWindow.document.write(sHTML);
            oWindow.document.close();
        }

    },

    SwitchEditMode: function (noUndo) {
        var bIsWysiwyg = (FCK.EditMode == FCK_EDITMODE_WYSIWYG);

        // Save the current IsDirty state, so we may restore it after the switch.
        var bIsDirty = FCK.IsDirty();

        var sHtml;

        // Update the HTML in the view output to show, also update
        // FCKTempBin for IE to avoid #2263.
        if (bIsWysiwyg) {
            FCKCommands.GetCommand('ShowBlocks').SaveState();
            if (!noUndo && FCKBrowserInfo.IsIE)
                FCKUndo.SaveUndoStep();

            sHtml = FCK.GetXHTML(FCKConfig.FormatSource);

            if (FCKBrowserInfo.IsIE)
                FCKTempBin.ToHtml();

            if (sHtml == null)
                return false;
        }
        else
            sHtml = this.EditingArea.Textarea.value;

        FCK.EditMode = bIsWysiwyg ? FCK_EDITMODE_SOURCE : FCK_EDITMODE_WYSIWYG;

        FCK.SetData(sHtml, !bIsDirty);

        // Set the Focus.
        FCK.Focus();

        // Update the toolbar (Running it directly causes IE to fail).
        FCKTools.RunFunction(FCK.ToolbarSet.RefreshModeState, FCK.ToolbarSet);

        return true;
    },

    InsertElement: function (element) {
        // The parameter may be a string (element name), so transform it in an element.
        if (typeof element == 'string')
            element = this.EditorDocument.createElement(element);

        var elementName = element.nodeName.toLowerCase();

        FCKSelection.Restore();

        // Create a range for the selection. V3 will have a new selection
        // object that may internally supply this feature.
        var range = new FCKDomRange(this.EditorWindow);

        // Move to the selection and delete it.
        range.MoveToSelection();
        range.DeleteContents();

        if (FCKListsLib.BlockElements[elementName] != null) {
            if (range.StartBlock) {
                if (range.CheckStartOfBlock())
                    range.MoveToPosition(range.StartBlock, 3);
                else if (range.CheckEndOfBlock())
                    range.MoveToPosition(range.StartBlock, 4);
                else
                    range.SplitBlock();
            }

            range.InsertNode(element);

            var next = FCKDomTools.GetNextSourceElement(element, false, null, ['hr', 'br', 'param', 'img', 'area', 'input'], true);

            // Be sure that we have something after the new element, so we can move the cursor there.
            if (!next && FCKConfig.EnterMode != 'br') {
                next = this.EditorDocument.body.appendChild(this.EditorDocument.createElement(FCKConfig.EnterMode));

                if (FCKBrowserInfo.IsGeckoLike)
                    FCKTools.AppendBogusBr(next);
            }

            if (FCKListsLib.EmptyElements[elementName] == null)
                range.MoveToElementEditStart(element);
            else if (next)
                range.MoveToElementEditStart(next);
            else
                range.MoveToPosition(element, 4);

            if (FCKBrowserInfo.IsGeckoLike) {
                if (next)
                    FCKDomTools.ScrollIntoView(next, false);
                FCKDomTools.ScrollIntoView(element, false);
            }
        }
        else {
            // Insert the node.
            range.InsertNode(element);

            // Move the selection right after the new element.
            // DISCUSSION: Should we select the element instead?
            range.SetStart(element, 4);
            range.SetEnd(element, 4);
        }

        range.Select();
        range.Release();

        // REMOVE IT: The focus should not really be set here. It is up to the
        // calling code to reset the focus if needed.
        this.Focus();

        return element;
    },

    _InsertBlockElement: function (blockElement) {
    },

    _IsFunctionKey: function (keyCode) {
        // keys that are captured but do not change editor contents
        if (keyCode >= 16 && keyCode <= 20)
        // shift, ctrl, alt, pause, capslock
            return true;
        if (keyCode == 27 || (keyCode >= 33 && keyCode <= 40))
        // esc, page up, page down, end, home, left, up, right, down
            return true;
        if (keyCode == 45)
        // insert, no effect on FCKeditor, yet
            return true;
        return false;
    },

    _KeyDownListener: function (evt) {
        if (!evt)
            evt = FCK.EditorWindow.event;
        if (FCK.EditorWindow) {
            if (!FCK._IsFunctionKey(evt.keyCode) // do not capture function key presses, like arrow keys or shift/alt/ctrl
					&& !(evt.ctrlKey || evt.metaKey) // do not capture Ctrl hotkeys, as they have their snapshot capture logic
					&& !(evt.keyCode == 46)) // do not capture Del, it has its own capture logic in fckenterkey.js
                FCK._KeyDownUndo();
        }
        return true;
    },

    _KeyDownUndo: function () {
        if (!FCKUndo.Typing) {
            FCKUndo.SaveUndoStep();
            FCKUndo.Typing = true;
            FCK.Events.FireEvent("OnSelectionChange");
        }

        FCKUndo.TypesCount++;
        FCKUndo.Changed = 1;

        if (FCKUndo.TypesCount > FCKUndo.MaxTypes) {
            FCKUndo.TypesCount = 0;
            FCKUndo.SaveUndoStep();
        }
    },

    _TabKeyHandler: function (evt) {
        if (!evt)
            evt = window.event;

        var keystrokeValue = evt.keyCode;

        // Pressing <Tab> in source mode should produce a tab space in the text area, not
        // changing the focus to something else.
        if (keystrokeValue == 9 && FCK.EditMode != FCK_EDITMODE_WYSIWYG) {
            if (FCKBrowserInfo.IsIE) {
                var range = document.selection.createRange();
                if (range.parentElement() != FCK.EditingArea.Textarea)
                    return true;
                range.text = '\t';
                range.select();
            }
            else {
                var a = [];
                var el = FCK.EditingArea.Textarea;
                var selStart = el.selectionStart;
                var selEnd = el.selectionEnd;
                a.push(el.value.substr(0, selStart));
                a.push('\t');
                a.push(el.value.substr(selEnd));
                el.value = a.join('');
                el.setSelectionRange(selStart + 1, selStart + 1);
            }

            if (evt.preventDefault)
                return evt.preventDefault();

            return evt.returnValue = false;
        }

        return true;
    }
};

FCK.Events = new FCKEvents( FCK ) ;

// DEPRECATED in favor or "GetData".
FCK.GetHTML	= FCK.GetXHTML = FCK.GetData ;

// DEPRECATED in favor of "SetData".
FCK.SetHTML = FCK.SetData ;

// InsertElementAndGetIt and CreateElement are Deprecated : returns the same value as InsertElement.
FCK.InsertElementAndGetIt = FCK.CreateElement = FCK.InsertElement ;

// Replace all events attributes (like onclick).
function _FCK_ProtectEvents_ReplaceTags( tagMatch )
{
	return tagMatch.replace( FCKRegexLib.EventAttributes, _FCK_ProtectEvents_ReplaceEvents ) ;
}

// Replace an event attribute with its respective __fckprotectedatt attribute.
// The original event markup will be encoded and saved as the value of the new
// attribute.
function _FCK_ProtectEvents_ReplaceEvents( eventMatch, attName )
{
	return ' ' + attName + '_fckprotectedatt="' + encodeURIComponent( eventMatch ) + '"' ;
}

function _FCK_ProtectEvents_RestoreEvents( match, encodedOriginal )
{
	return decodeURIComponent( encodedOriginal ) ;
}

function _FCK_MouseEventsListener( evt )
{
	if ( ! evt )
		evt = window.event ;
	if ( evt.type == 'mousedown' )
		FCK.MouseDownFlag = true ;
	else if ( evt.type == 'mouseup' )
		FCK.MouseDownFlag = false ;
	else if ( evt.type == 'mousemove' )
		FCK.Events.FireEvent( 'OnMouseMove', evt ) ;
}

function _FCK_PaddingNodeListener()
{
	if ( FCKConfig.EnterMode.IEquals( 'br' ) )
		return ;
	FCKDomTools.EnforcePaddingNode( FCK.EditorDocument, FCKConfig.EnterMode ) ;

	if ( ! FCKBrowserInfo.IsIE && FCKDomTools.PaddingNode )
	{
		// Prevent the caret from going between the body and the padding node in Firefox.
		// i.e. <body>|<p></p></body>
		var sel = FCKSelection.GetSelection() ;
		if ( sel && sel.rangeCount == 1 )
		{
			var range = sel.getRangeAt( 0 ) ;
			if ( range.collapsed && range.startContainer == FCK.EditorDocument.body && range.startOffset == 0 )
			{
				range.selectNodeContents( FCKDomTools.PaddingNode ) ;
				range.collapse( true ) ;
				sel.removeAllRanges() ;
				sel.addRange( range ) ;
			}
		}
	}
	else if ( FCKDomTools.PaddingNode )
	{
		// Prevent the caret from going into an empty body but not into the padding node in IE.
		// i.e. <body><p></p>|</body>
		var parentElement = FCKSelection.GetParentElement() ;
		var paddingNode = FCKDomTools.PaddingNode ;
		if ( parentElement && parentElement.nodeName.IEquals( 'body' ) )
		{
			if ( FCK.EditorDocument.body.childNodes.length == 1
					&& FCK.EditorDocument.body.firstChild == paddingNode )
			{
				/*
				 * Bug #1764: Don't move the selection if the
				 * current selection isn't in the editor
				 * document.
				 */
				if ( FCKSelection._GetSelectionDocument( FCK.EditorDocument.selection ) != FCK.EditorDocument )
					return ;

				var range = FCK.EditorDocument.body.createTextRange() ;
				var clearContents = false ;
				if ( !paddingNode.childNodes.firstChild )
				{
					paddingNode.appendChild( FCKTools.GetElementDocument( paddingNode ).createTextNode( '\ufeff' ) ) ;
					clearContents = true ;
				}
				range.moveToElementText( paddingNode ) ;
				range.select() ;
				if ( clearContents )
					range.pasteHTML( '' ) ;
			}
		}
	}
}

function _FCK_EditingArea_OnLoad()
{
	// Get the editor's window and document (DOM)
	FCK.EditorWindow	= FCK.EditingArea.Window ;
	FCK.EditorDocument	= FCK.EditingArea.Document ;

	if ( FCKBrowserInfo.IsIE )
		FCKTempBin.ToElements() ;

	FCK.InitializeBehaviors() ;

	// Listen for mousedown and mouseup events for tracking drag and drops.
	FCK.MouseDownFlag = false ;
	FCKTools.AddEventListener( FCK.EditorDocument, 'mousemove', _FCK_MouseEventsListener ) ;
	FCKTools.AddEventListener( FCK.EditorDocument, 'mousedown', _FCK_MouseEventsListener ) ;
	FCKTools.AddEventListener( FCK.EditorDocument, 'mouseup', _FCK_MouseEventsListener ) ;

	// Most of the CTRL key combos do not work under Safari for onkeydown and onkeypress (See #1119)
	// But we can use the keyup event to override some of these...
	if ( FCKBrowserInfo.IsSafari )
	{
		var undoFunc = function( evt )
		{
			if ( ! ( evt.ctrlKey || evt.metaKey ) )
				return ;
			if ( FCK.EditMode != FCK_EDITMODE_WYSIWYG )
				return ;
			switch ( evt.keyCode )
			{
				case 89:
					FCKUndo.Redo() ;
					break ;
				case 90:
					FCKUndo.Undo() ;
					break ;
			}
		}

		FCKTools.AddEventListener( FCK.EditorDocument, 'keyup', undoFunc ) ;
	}

	// Create the enter key handler
	FCK.EnterKeyHandler = new FCKEnterKey( FCK.EditorWindow, FCKConfig.EnterMode, FCKConfig.ShiftEnterMode, FCKConfig.TabSpaces ) ;

	// Listen for keystroke events.
	FCK.KeystrokeHandler.AttachToElement( FCK.EditorDocument ) ;

	if ( FCK._ForceResetIsDirty )
		FCK.ResetIsDirty() ;

	// This is a tricky thing for IE. In some cases, even if the cursor is
	// blinking in the editing, the keystroke handler doesn't catch keyboard
	// events. We must activate the editing area to make it work. (#142).
	if ( FCKBrowserInfo.IsIE && FCK.HasFocus )
		FCK.EditorDocument.body.setActive() ;

	FCK.OnAfterSetHTML() ;

	// Restore show blocks status.
	FCKCommands.GetCommand( 'ShowBlocks' ).RestoreState() ;

	// Check if it is not a startup call, otherwise complete the startup.
	if ( FCK.Status != FCK_STATUS_NOTLOADED )
		return ;

	FCK.SetStatus( FCK_STATUS_ACTIVE ) ;
}

function _FCK_GetEditorAreaStyleTags()
{
	return FCKTools.GetStyleHtml( FCKConfig.EditorAreaCSS ) +
		FCKTools.GetStyleHtml( FCKConfig.EditorAreaStyles ) ;
}

function _FCK_KeystrokeHandler_OnKeystroke( keystroke, keystrokeValue )
{
	if ( FCK.Status != FCK_STATUS_COMPLETE )
		return false ;

	if ( FCK.EditMode == FCK_EDITMODE_WYSIWYG )
	{
		switch ( keystrokeValue )
		{
			case 'Paste' :
				return !FCK.Paste() ;

			case 'Cut' :
				FCKUndo.SaveUndoStep() ;
				return false ;
		}
	}
	else
	{
		// In source mode, some actions must have their default behavior.
		if ( keystrokeValue.Equals( 'Paste', 'Undo', 'Redo', 'SelectAll', 'Cut' ) )
			return false ;
	}

	// The return value indicates if the default behavior of the keystroke must
	// be cancelled. Let's do that only if the Execute() call explicitly returns "false".
	var oCommand = FCK.Commands.GetCommand( keystrokeValue ) ;

	// If the command is disabled then ignore the keystroke
	if ( oCommand.GetState() == FCK_TRISTATE_DISABLED )
		return false ;

	return ( oCommand.Execute.apply( oCommand, FCKTools.ArgumentsToArray( arguments, 2 ) ) !== false ) ;
}

// Set the FCK.LinkedField reference to the field that will be used to post the
// editor data.
(function()
{
	// There is a bug on IE... getElementById returns any META tag that has the
	// name set to the ID you are looking for. So the best way in to get the array
	// by names and look for the correct one.
	// As ASP.Net generates a ID that is different from the Name, we must also
	// look for the field based on the ID (the first one is the ID).

	var oDocument = window.parent.document ;

	// Try to get the field using the ID.
	var eLinkedField = oDocument.getElementById( FCK.Name ) ;

	var i = 0;
	while ( eLinkedField || i == 0 )
	{
		if ( eLinkedField && eLinkedField.tagName.toLowerCase().Equals( 'input', 'textarea' ) )
		{
			FCK.LinkedField = eLinkedField ;
			break ;
		}

		eLinkedField = oDocument.getElementsByName( FCK.Name )[i++] ;
	}
})() ;

var FCKTempBin =
{
	Elements : new Array(),

	AddElement : function( element )
	{
		var iIndex = this.Elements.length ;
		this.Elements[ iIndex ] = element ;
		return iIndex ;
	},

	RemoveElement : function( index )
	{
		var e = this.Elements[ index ] ;
		this.Elements[ index ] = null ;
		return e ;
	},

	Reset : function()
	{
		var i = 0 ;
		while ( i < this.Elements.length )
			this.Elements[ i++ ] = null ;
		this.Elements.length = 0 ;
	},

	ToHtml : function()
	{
		for ( var i = 0 ; i < this.Elements.length ; i++ )
		{
			this.Elements[i] = '<div>&nbsp;' + this.Elements[i].outerHTML + '</div>' ;
			this.Elements[i].isHtml = true ;
		}
	},

	ToElements : function()
	{
		var node = FCK.EditorDocument.createElement( 'div' ) ;
		for ( var i = 0 ; i < this.Elements.length ; i++ )
		{
			if ( this.Elements[i].isHtml )
			{
				node.innerHTML = this.Elements[i] ;
				this.Elements[i] = node.firstChild.removeChild( node.firstChild.lastChild ) ;
			}
		}
	}
} ;



// # Focus Manager: Manages the focus in the editor.
var FCKFocusManager = FCK.FocusManager =
{
	IsLocked : false,

	AddWindow : function( win, sendToEditingArea )
	{
		var oTarget ;

		if ( FCKBrowserInfo.IsIE )
			oTarget = win.nodeType == 1 ? win : win.frameElement ? win.frameElement : win.document ;
		else if ( FCKBrowserInfo.IsSafari )
			oTarget = win ;
		else
			oTarget = win.document ;

		FCKTools.AddEventListener( oTarget, 'blur', FCKFocusManager_Win_OnBlur ) ;
		FCKTools.AddEventListener( oTarget, 'focus', sendToEditingArea ? FCKFocusManager_Win_OnFocus_Area : FCKFocusManager_Win_OnFocus ) ;
	},

	RemoveWindow : function( win )
	{
		if ( FCKBrowserInfo.IsIE )
			oTarget = win.nodeType == 1 ? win : win.frameElement ? win.frameElement : win.document ;
		else
			oTarget = win.document ;

		FCKTools.RemoveEventListener( oTarget, 'blur', FCKFocusManager_Win_OnBlur ) ;
		FCKTools.RemoveEventListener( oTarget, 'focus', FCKFocusManager_Win_OnFocus_Area ) ;
		FCKTools.RemoveEventListener( oTarget, 'focus', FCKFocusManager_Win_OnFocus ) ;
	},

	Lock : function()
	{
		this.IsLocked = true ;
	},

	Unlock : function()
	{
		if ( this._HasPendingBlur )
			FCKFocusManager._Timer = window.setTimeout( FCKFocusManager_FireOnBlur, 100 ) ;

		this.IsLocked = false ;
	},

	_ResetTimer : function()
	{
		this._HasPendingBlur = false ;

		if ( this._Timer )
		{
			window.clearTimeout( this._Timer ) ;
			delete this._Timer ;
		}
	}
} ;

function FCKFocusManager_Win_OnBlur()
{
	if ( typeof(FCK) != 'undefined' && FCK.HasFocus )
	{
		FCKFocusManager._ResetTimer() ;
		FCKFocusManager._Timer = window.setTimeout( FCKFocusManager_FireOnBlur, 100 ) ;
	}
}

function FCKFocusManager_FireOnBlur()
{
	if ( FCKFocusManager.IsLocked )
		FCKFocusManager._HasPendingBlur = true ;
	else
	{
		FCK.HasFocus = false ;
		FCK.Events.FireEvent( "OnBlur" ) ;
	}
}

function FCKFocusManager_Win_OnFocus_Area()
{
	// Check if we are already focusing the editor (to avoid loops).
	if ( FCKFocusManager._IsFocusing )
		return ;

	FCKFocusManager._IsFocusing = true ;

	FCK.Focus() ;
	FCKFocusManager_Win_OnFocus() ;

	// The above FCK.Focus() call may trigger other focus related functions.
	// So, to avoid a loop, we delay the focusing mark removal, so it get
	// executed after all othre functions have been run.
	FCKTools.RunFunction( function()
		{
			delete FCKFocusManager._IsFocusing ;
		} ) ;
}

function FCKFocusManager_Win_OnFocus()
{
	FCKFocusManager._ResetTimer() ;

	if ( !FCK.HasFocus && !FCKFocusManager.IsLocked )
	{
		FCK.HasFocus = true ;
		FCK.Events.FireEvent( "OnFocus" ) ;
	}
}

/*
 * #1633 : Protect the editor iframe from external styles.
 * Notice that we can't use FCKTools.ResetStyles here since FCKTools isn't
 * loaded yet.
 */
(function()
{
	var el = window.frameElement ;
	var width = el.width ;
	var height = el.height ;
	if ( /^\d+$/.test( width ) ) width += 'px' ;
	if ( /^\d+$/.test( height ) ) height += 'px' ;
	var style = el.style ;
	style.border = style.padding = style.margin = 0 ;
	style.backgroundColor = 'transparent';
	style.backgroundImage = 'none';
	style.width = width ;
	style.height = height ;
})() ;
